home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WW3DKit / RIBCommand.m < prev    next >
Encoding:
Text File  |  1995-03-22  |  34.8 KB  |  1,076 lines
  1. // copyright 1993 Michael B. Johnson; some portions copyright 1994, MIT
  2. // see COPYRIGHT for reuse legalities
  3. //
  4.  
  5. #import "RIBCommand.h"
  6. #import "WWEveParser.h"  // for the WW_ defines...
  7. #import "WWSceneClock.h"
  8. #import "WW3DAttributeState.h"
  9. #import <stdio.h>
  10.  
  11. @implementation RIBCommand
  12.  
  13. + initialize { return [RIBCommand setVersion:1], self; }
  14.  
  15. - init
  16. {
  17.   [super init];
  18.  
  19.   n = 0;
  20.   tokens = (RtToken *)NULL;
  21.   parms = (RtPointer *)NULL;
  22.   archiveVector = (char **)NULL;
  23.   printfNVector = (int *)NULL;
  24.   printfTypeVector = (int *)NULL;
  25.  
  26.   dirtyBoundingBox = TRUE;
  27.  
  28.   return self;
  29. }
  30.  
  31.  
  32. - awake
  33. {
  34.   [super awake];
  35.  
  36.   dirtyBoundingBox = TRUE;
  37.  
  38.   return self;
  39. }
  40.  
  41.  
  42. - (void)setN:(int)newN tokens:(RtToken *)newTokens parms:(RtPointer *)newParms archiveVector:(char **)newArchiveVector printfTypeVector:(int *)newPrintfTypeVector printfNVector:(int *)newPrintfNVector
  43. {  
  44.    int  i;
  45.  
  46.  
  47.    if (n)
  48.    {  for (i = 0; i < n; i++)
  49.       {  // don't free the tokens; they're shared!
  50.          free(parms[i]);
  51.          free(archiveVector[i]);
  52.          free(printfNVector);
  53.          free(printfTypeVector);
  54.       }
  55.       if (newN > n)
  56.       {  tokens = (RtToken *)NXZoneRealloc([self zone], tokens, (newN * sizeof(RtToken)));
  57.          parms = (RtPointer *)NXZoneRealloc([self zone], parms, (newN * sizeof(RtPointer)));
  58.          archiveVector = (char **)NXZoneRealloc([self zone], archiveVector, (newN * sizeof(archiveVector)));
  59.          printfNVector = (int *)NXZoneRealloc([self zone], printfNVector, (newN * sizeof(int)));
  60.          printfTypeVector = (int *)NXZoneRealloc([self zone], printfTypeVector, (newN * sizeof(int)));
  61.       }
  62.    }
  63.    else
  64.    {  tokens = (RtToken *)NXZoneMalloc([self zone], newN * sizeof(RtToken));
  65.       parms = (RtPointer *)NXZoneMalloc([self zone], newN * sizeof(RtPointer));
  66.       archiveVector = (char **)NXZoneMalloc([self zone], newN * sizeof(archiveVector));
  67.       printfNVector = (int *)NXZoneMalloc([self zone], newN * sizeof(int));
  68.       printfTypeVector = (int *)NXZoneMalloc([self zone], newN * sizeof(int));
  69.    }
  70.    n = newN;
  71.    for (i = 0; i < n; i++)
  72.    {  tokens[i] = newTokens[i];
  73.       parms[i] = newParms[i];
  74.       archiveVector[i] = newArchiveVector[i];
  75.       printfNVector[i] = newPrintfNVector[i];
  76.       printfTypeVector[i] = newPrintfTypeVector[i];
  77.    }
  78.  
  79.    dirtyBoundingBox = TRUE;
  80.    return ;
  81. }
  82.  
  83. - free
  84. {
  85.   int i;
  86.  
  87.  
  88.   //NXLogError("%s %d being free'ed\n", [[self class] name], self);
  89.   // don't free the tokens; they're constants (i.e. RI_P, RI_PW, etc.)
  90.   //NXLogError("RIBCommand %s: freeing %p", [[self class] name], self);
  91.   for (i = 0; i < n; i++)
  92.   {  if (parms[i]) { free(parms[i]); }
  93.      if (archiveVector[i]) { free(archiveVector[i]); }
  94.   }
  95.   if (n)  
  96.   {  if (printfNVector) { free(printfNVector); }
  97.      if (printfTypeVector) { free(printfTypeVector); }
  98.   }
  99.   return [super free];
  100. }
  101.  
  102. // this should only be called internally
  103. // the receiving object needs to copy all the parameters using the passed in zone
  104. // the assumption is that 
  105. - _mallocPointersUsingZone:(NXZone *)zone
  106. {
  107.    if (n)
  108.    {  tokens = (RtToken *)NXZoneMalloc([self zone], n * sizeof(RtToken));
  109.       if (!tokens)
  110.       {  return nil;
  111.       }
  112.       parms = (RtPointer *)NXZoneMalloc([self zone], n * sizeof(RtPointer));
  113.       if (!parms)
  114.       {  NXZoneFree(zone, tokens);
  115.          return nil;
  116.       }
  117.       archiveVector = (char **)NXZoneMalloc([self zone], n * sizeof(char *));
  118.       if (!archiveVector)
  119.       {  NXZoneFree(zone, tokens);
  120.          NXZoneFree(zone, parms);
  121.          return nil;
  122.       }
  123.       printfNVector = (int *)NXZoneMalloc([self zone], n * sizeof(int));
  124.       if (!printfNVector)
  125.       {  NXZoneFree(zone, tokens);
  126.          NXZoneFree(zone, parms);
  127.          NXZoneFree(zone, archiveVector);
  128.          return nil;
  129.       }
  130.       printfTypeVector = (int *)NXZoneMalloc([self zone], n * sizeof(int));
  131.       if (!printfTypeVector)
  132.       {  NXZoneFree(zone, tokens);
  133.          NXZoneFree(zone, parms);
  134.          NXZoneFree(zone, archiveVector);
  135.          NXZoneFree(zone, printfNVector);
  136.          return nil;
  137.       }
  138.    }
  139.    else
  140.    {  // n == 0
  141.       tokens = (RtToken *)NULL;
  142.       parms = (RtPointer *)NULL;
  143.       archiveVector = (char **)NULL;
  144.       printfNVector = (int *)NULL;
  145.       printfTypeVector = (int *)NULL;
  146.    }
  147.    return self;
  148. }
  149.  
  150. - _setToken:(char *)newToken parm:(RtPointer)newParm i:(int)i archiveInfo:(char *)archiveInfo type:(int)parmType count:(int)howMany usingZone:(NXZone *)zone
  151. {
  152.    int  j;
  153.  
  154.  
  155.    tokens[i] = (RtToken)NXZoneMalloc(zone, (1 + strlen(newToken)));
  156.    if (!tokens[i])
  157.    {  return nil;
  158.    }
  159.    strcpy(tokens[i], newToken);
  160.  
  161.    archiveVector[i] = (char *)NXZoneMalloc(zone, (1 + strlen(archiveInfo)));
  162.    if (!archiveVector[i])
  163.    {  NXZoneFree(zone, tokens[i]);
  164.       return nil;
  165.    }
  166.    strcpy(archiveVector[i], archiveInfo);
  167.  
  168.    printfTypeVector[i] = parmType;
  169.    printfNVector[i] = howMany;
  170.  
  171.    // in a perfect world, I could just copy that chunk o memory over,
  172.    // but I'm worried about alignment problems, so I'll do it the slow way...
  173.    switch (printfTypeVector[i])
  174.    {  case WW_FLOAT:  parms[i] = (RtFloat *)NXZoneMalloc(zone, sizeof(RtFloat) * howMany); 
  175.                       for (j = 0; j < printfNVector[i]; j++)
  176.               {  *((RtFloat *)parms[i] + j) = *((RtFloat *)(newParm) + j);
  177.               }
  178.                       break;
  179.       case WW_COLOR:  parms[i] = (RtFloat *)NXZoneMalloc(zone, sizeof(RtFloat) * howMany); 
  180.                       for (j = 0; j < printfNVector[i]; j++)
  181.               {  *((RtFloat *)parms[i] + j) = *((RtFloat *)(newParm) + j);
  182.               }
  183.                       break;
  184.       case WW_POINT:  parms[i] = (RtFloat *)NXZoneMalloc(zone, sizeof(RtFloat) * howMany); 
  185.                       for (j = 0; j < printfNVector[i]; j++)
  186.               {  *((RtFloat *)parms[i] + j) = *((RtFloat *)(newParm) + j);
  187.               }
  188.                       break;
  189.       case WW_INT:    parms[i] = (int *)NXZoneMalloc(zone, sizeof(int) * howMany); 
  190.                       for (j = 0; j < printfNVector[i]; j++)
  191.               {  *((int *)parms[i] + j) = *((int *)(newParm) + j);
  192.               }
  193.                       break;
  194.       // hmm, strings are weirder.  
  195.       case WW_STRING: parms[i] = (char **)NXZoneMalloc(zone, sizeof(char *) * howMany); 
  196.                       for (j = 0; j < printfNVector[i]; j++)
  197.               {  // need to additionally malloc up some memory here, folks
  198.                          *((char **)parms[i] + j) = (char *)NXZoneMalloc(zone, (1 + strlen(*((char **)(newParm) + j))));
  199.                          strcpy(*((char **)parms[i] + j), *((char **)(newParm) + j));
  200.               }
  201.                       break;
  202.    }      
  203.    return self;
  204. }
  205.  
  206.  
  207. - copyFromZone:(NXZone *)zone
  208. {
  209.   int  i;
  210.   id   newCopy = [super copyFromZone:zone];
  211.  
  212.   // now we need to grovel over the parameters and copy them 
  213.   // this is a pain, but boy, will it be cool...
  214.   // okay, malloc up the base list of pointers
  215.   [newCopy _mallocPointersUsingZone:zone];
  216.   for (i = 0; i < n; i++)
  217.   {  if (![newCopy _setToken:tokens[i] parm:parms[i] i:i 
  218.                        archiveInfo:archiveVector[i] type:printfTypeVector[i] count:printfNVector[i] 
  219.                        usingZone:zone])
  220.      {  [newCopy free];
  221.         return nil;
  222.      }
  223.   }
  224.   
  225.   return newCopy;
  226. }
  227.  
  228. - _lerpParametersWith:b by:(float)u
  229. {
  230.   int        i, j;
  231.   RtToken    *tokensB;
  232.   char       **archiveVectorB;
  233.   int        *printfNVectorB;
  234.   int        *printfTypeVectorB;
  235.   RtPointer  *parmsB;
  236.  
  237.  
  238.   // okay, first thing to realize is that this instance already has its 
  239.   // parameters set to the (u ==0) case here.  Therefore, when in doubt, 
  240.   // you can leave it alone and you're fine.  We now want to grovel 
  241.   // over the two objects' parameters.  
  242.   if (n != [b n])
  243.   { // hmm.  looks like trouble.  At some point, we'll have to bail,
  244.     // since the parameter lists aren't the same length.  we could
  245.     // bail right away, since we know that "self"'s parameters are set
  246.     // to something reasonable...  Yea, let's bail.
  247.     return self;
  248.   }
  249.  
  250.   tokensB = [b tokens];
  251.   archiveVectorB = [b archiveVector];
  252.   printfNVectorB = [b printfNVector];
  253.   printfTypeVectorB = [b printfTypeVector];
  254.   parmsB = [b parms];
  255.  
  256.   // okay, at this point, we know that these two objects are the same 
  257.   // class, and the length of their parameter lists are the same. Of
  258.   // course, this might be just a lucky coincidence, and the actual 
  259.   // parameters might be different types.  
  260.  
  261.   for (i = 0; i < n; i++)
  262.   {  if ((tokens[i] == tokensB[i]) || (!strcmp(tokens[i], tokensB[i])))
  263.      {  // great! they're the same token.
  264.         // now we need to make sure they're the same type and length of data
  265.         // if not, bail to the next parameter
  266.         if ((printfNVector[i] == printfNVectorB[i]) && (printfTypeVector[i] == printfTypeVectorB[i]))
  267.     {  // okay! we're golden. Let's do a lerp...
  268.            switch (printfTypeVector[i])
  269.            {  case WW_FLOAT:   for (j = 0; j < printfNVector[i]; j++)
  270.                        {  *((RtFloat *)parms[i] + j) += ((*((RtFloat *)(parmsB[i]) + j) - *((RtFloat *)parms[i] + j)) * u);
  271.                        }
  272.                                break;
  273.               case WW_COLOR:   for (j = 0; j < printfNVector[i]; j++)
  274.                        {  *((RtFloat *)parms[i] + j) += ((*((RtFloat *)(parmsB[i]) + j) - *((RtFloat *)parms[i] + j)) * u);
  275.                        }
  276.                                break;
  277.               case WW_POINT:   for (j = 0; j < printfNVector[i]; j++)
  278.                        {  *((RtFloat *)parms[i] + j) += ((*((RtFloat *)(parmsB[i]) + j) - *((RtFloat *)parms[i] + j)) * u);
  279.                        }
  280.                                break;
  281.               case WW_INT:     for (j = 0; j < printfNVector[i]; j++)
  282.                        {  *((int *)parms[i] + j) += ((*((int *)(parmsB[i]) + j) - *((int *)parms[i] + j)) * u);
  283.                    }
  284.                                break;
  285.               case WW_STRING:  // can't lerp strings without more info...
  286.                                // maybe could encode a way to do it with enumerated values, but for now, bail...
  287.                                break;
  288.            }
  289.         }
  290.         else
  291.         {  // okay, that parameter can't be lerp'ed; on to the next
  292.         }
  293.      }
  294.      else
  295.      {  // okay, that parameter can't be lerp'ed; on to the next
  296.      }
  297.   }
  298.  
  299.   
  300.  
  301.   return self;
  302. }
  303.  
  304.  
  305. // note: because we've made the WWSampleList "safe" for having
  306. // multiple samples with the same data, it's perfectly valid to return
  307. // yourself or b
  308. - lerpWith:b by:(float)uValue
  309. {
  310.    id  newMe = nil;
  311.  
  312.  
  313.    if (([self class] != [b class]) || (uValue <= 0.0))
  314.    {  return self;
  315.    }
  316.  
  317.    if (uValue >= 1.0)
  318.    {  return b;
  319.    }
  320.  
  321.    newMe = [self copyFromZone:[self zone]];
  322.  
  323.    // okay, now we have to get newMe to linearly interpolate it
  324.    // parameters partway between "self" and "b"
  325.    [newMe _lerpParametersWith:b by:uValue];
  326.  
  327.    return newMe;
  328. }
  329.  
  330. - lerpSelfWith:b by:(float)uValue
  331. {
  332.    if (([self class] != [b class]) || (uValue <= 0.0))
  333.    {  return self;
  334.    }
  335.  
  336.    if (uValue >= 1.0)
  337.    {  return b;
  338.    }
  339.  
  340.    // okay, now we have to get newMe to linearly interpolate it
  341.    // parameters partway between "self" and "b"
  342.    [self _lerpParametersWith:b by:uValue];
  343.  
  344.    return self;
  345. }
  346.  
  347. - (BOOL)pushesOrPopsCTM { return NO; }
  348. - (BOOL)pushesCTM { return NO; }
  349. - (BOOL)popsCTM { return NO; }
  350.  
  351. - (BOOL)hasBoundingBox { return NO; }
  352.  
  353. - (float)lastSampleIsAt { return 0.0; }
  354.  
  355. - (unsigned long int)maxSampleBandwidth  
  356. {  
  357.    unsigned long int maxSampleBandwidth = 0;
  358.    int  i, j;
  359.  
  360.   
  361.    if (!n)
  362.    {  return maxSampleBandwidth;
  363.    }
  364.    for (i = 0; i < n; i++)
  365.    {  maxSampleBandwidth += 1 + strlen(tokens[i]);
  366.       switch (printfTypeVector[i])
  367.       {  case WW_FLOAT:   maxSampleBandwidth += (printfNVector[i] * sizeof(RtFloat));
  368.                           break;
  369.          case WW_COLOR:   maxSampleBandwidth += (printfNVector[i] * sizeof(RtFloat));
  370.                           break;
  371.          case WW_POINT:   maxSampleBandwidth += (printfNVector[i] * sizeof(RtFloat));
  372.                           break;
  373.          case WW_INT:     maxSampleBandwidth += (printfNVector[i] * sizeof(long));
  374.                           break;
  375.          case WW_STRING:  for (j = 0; j < printfNVector[i]; j++)
  376.                        {  maxSampleBandwidth += 1 + strlen(*((char **)(parms[i]) + j));
  377.               }
  378.                           break;
  379.       }      
  380.    }
  381.    return maxSampleBandwidth;
  382. }
  383.  
  384. - deriveHowManyPoints:(char *)archiveStr ofLength:(int)divisor
  385. {
  386.   char howManyStr[32];
  387.  
  388.  
  389.   // the string looks like "[1234f]"
  390.   strcpy(howManyStr, (archiveStr + 1));
  391.   howManyStr[strlen(howManyStr) - 2] = '\0';
  392.   howManyPoints = atoi(howManyStr) / divisor;
  393.  
  394.   return self;
  395. }
  396.  
  397. - (BOOL)isMoot  {  return NO;  }
  398. - (BOOL)isMootStartingAt:(float)startTime endingAt:(float)endTime  {  return [self isMoot];  }
  399.  
  400. // this routine, on the other hand, should be called by subclasses implementing -theSameAs:
  401. - (BOOL)theSameAs:otherRIBCommand
  402. {
  403.   int  i, j;
  404.   RtToken    *tokens2;
  405.   RtPointer  *parms2;
  406.   int        *printfNVector2;
  407.   int        *printfTypeVector2;
  408.  
  409.   
  410.   if ([self class] != [otherRIBCommand class])
  411.   {  return NO;
  412.   }
  413.  
  414.   if (n != [otherRIBCommand n])
  415.   {  return NO;
  416.   }
  417.  
  418.   tokens2 = [otherRIBCommand tokens];
  419.   parms2 = [otherRIBCommand parms];
  420.   printfNVector2 = [otherRIBCommand printfNVector];
  421.   printfTypeVector2 = [otherRIBCommand printfTypeVector];
  422.  
  423.   // note that there is a false (but probably okay) assumption here
  424.   // that the parameters are in the same order.  This doesn't have to be
  425.   // true, but for my stuff, probably will be true.
  426.   for (i = 0; i < n; i++)
  427.   {  if (tokens[i] != tokens2[i])
  428.      {  if (strcmp(tokens[i], tokens2[i]))
  429.         {  return NO;
  430.         }
  431.      }
  432.  
  433.      switch (printfTypeVector[i])
  434.      {  case WW_FLOAT:   if (printfNVector[i] != printfNVector2[i])
  435.                          {  return NO;
  436.                          }
  437.                          for (j = 0; j < printfNVector[i]; j++)
  438.                      {  if (*((RtFloat *)(parms[i]) + j) != *((RtFloat *)(parms2[i]) + j))
  439.                 return NO;
  440.              }
  441.                          break;
  442.         case WW_COLOR:   if (printfNVector[i] != printfNVector2[i])
  443.                          {  return NO;
  444.                          }
  445.                          for (j = 0; j < printfNVector[i]; j++)
  446.                      {  if (*((RtFloat *)(parms[i]) + j) != *((RtFloat *)(parms2[i]) + j))
  447.                 return NO;
  448.              }
  449.                          break;
  450.         case WW_POINT:   if (printfNVector[i] != printfNVector2[i])
  451.                          {  return NO;
  452.                          }
  453.                          for (j = 0; j < printfNVector[i]; j++)
  454.                      {  if (*((RtFloat *)(parms[i]) + j) != *((RtFloat *)(parms2[i]) + j))
  455.                 return NO;
  456.              }
  457.                          break;
  458.         case WW_INT:   if (printfNVector[i] != printfNVector2[i])
  459.                          {  return NO;
  460.                          }
  461.                          for (j = 0; j < printfNVector[i]; j++)
  462.                      {  if (*((RtInt *)(parms[i]) + j) != *((RtInt *)(parms2[i]) + j))
  463.                 return NO;
  464.              }
  465.                          break;
  466.         case WW_STRING:   if (printfNVector[i] != printfNVector2[i])
  467.                          {  return NO;
  468.                          }
  469.                          for (j = 0; j < printfNVector[i]; j++)
  470.                      {  if (strcmp(*((char **)(parms[i]) + j), *((char **)(parms2[i]) + j)))
  471.                 return NO;
  472.              }
  473.                          break;
  474.      }      
  475.   }
  476.   return YES;
  477. }
  478.  
  479.  
  480.  
  481. - (BOOL)similarTo:otherRIBCommand 
  482. {
  483.   if ([self class] != [otherRIBCommand class])
  484.   {  return NO;
  485.   }
  486.   if (n != [otherRIBCommand n])
  487.   {  return NO;
  488.   }
  489.   return YES;
  490. }
  491.  
  492.  
  493. - calculateBoundingBoxStartingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime
  494. {
  495.   int      i = 0, j = 1;
  496.   BOOL     notFound = YES;
  497.   RtFloat  *aPointPtr;
  498.  
  499.  
  500.   while (notFound && (i < n))
  501.   {  if (!strcmp(tokens[i], "P"))
  502.      {  notFound = NO;
  503.         aPointPtr = (RtFloat *)(parms[i]);
  504.     boundingBox[0] = aPointPtr[0];
  505.     boundingBox[1] = aPointPtr[0];
  506.     boundingBox[2] = aPointPtr[1];
  507.     boundingBox[3] = aPointPtr[1];
  508.     boundingBox[4] = aPointPtr[2];
  509.     boundingBox[5] = aPointPtr[2];
  510.         if (!howManyPoints)
  511.     {  [self deriveHowManyPoints:archiveVector[i] ofLength:3];
  512.         }
  513.         while (j++ < howManyPoints)
  514.         {  if (aPointPtr[0] < boundingBox[0]) { boundingBox[0] = aPointPtr[0]; }
  515.            if (aPointPtr[0] > boundingBox[1]) { boundingBox[1] = aPointPtr[0]; }
  516.            if (aPointPtr[1] < boundingBox[2]) { boundingBox[2] = aPointPtr[1]; }
  517.            if (aPointPtr[1] > boundingBox[3]) { boundingBox[3] = aPointPtr[1]; }
  518.            if (aPointPtr[2] < boundingBox[4]) { boundingBox[4] = aPointPtr[2]; }
  519.            if (aPointPtr[2] > boundingBox[5]) { boundingBox[5] = aPointPtr[2]; }
  520.            aPointPtr += 3;
  521.         }
  522.      }
  523.      if (!strcmp(tokens[i], "Pz"))
  524.      {  notFound = NO;
  525.         aPointPtr = (RtFloat *)(parms[i]);
  526.     boundingBox[0] = 0.0;
  527.     boundingBox[1] = 1.0;
  528.     boundingBox[2] = 0.0;
  529.     boundingBox[3] = 1.0;
  530.     boundingBox[4] = aPointPtr[0];
  531.     boundingBox[5] = aPointPtr[0];
  532.         if (!howManyPoints)
  533.     {  [self deriveHowManyPoints:archiveVector[i] ofLength:1];
  534.         }
  535.         while (j++ < howManyPoints)
  536.         {  if (aPointPtr[0] < boundingBox[4]) { boundingBox[4] = aPointPtr[0]; }
  537.            if (aPointPtr[0] > boundingBox[5]) { boundingBox[5] = aPointPtr[0]; }
  538.            aPointPtr++;
  539.         }
  540.      }
  541.      if (!strcmp(tokens[i], "Pw"))
  542.      {  notFound = NO;
  543.         aPointPtr = (RtFloat *)(parms[i]);
  544.     boundingBox[0] = ((aPointPtr[0]) / (aPointPtr[3]));
  545.     boundingBox[1] = ((aPointPtr[1]) / (aPointPtr[3]));
  546.     boundingBox[2] = ((aPointPtr[2]) / (aPointPtr[3]));
  547.     boundingBox[3] = ((aPointPtr[0]) / (aPointPtr[3]));
  548.     boundingBox[4] = ((aPointPtr[1]) / (aPointPtr[3]));
  549.     boundingBox[5] = ((aPointPtr[2]) / (aPointPtr[3]));
  550.         if (!howManyPoints)
  551.     {  [self deriveHowManyPoints:archiveVector[i] ofLength:4];
  552.         }
  553.         while (j++ < howManyPoints)
  554.         {  if ((aPointPtr[0]/aPointPtr[3]) < boundingBox[0])
  555.            { boundingBox[0] = (aPointPtr[0]/aPointPtr[3]); 
  556.            }
  557.            if ((aPointPtr[0]/aPointPtr[3]) > boundingBox[1])
  558.            { boundingBox[1] = (aPointPtr[0]/aPointPtr[3]); 
  559.            }
  560.            if ((aPointPtr[1]/aPointPtr[3]) < boundingBox[2])
  561.            { boundingBox[2] = (aPointPtr[1]/aPointPtr[3]); 
  562.            }
  563.            if ((aPointPtr[1]/aPointPtr[3]) > boundingBox[3])
  564.            { boundingBox[3] = (aPointPtr[1]/aPointPtr[3]); 
  565.            }
  566.            if ((aPointPtr[2]/aPointPtr[3]) < boundingBox[4])
  567.            { boundingBox[4] = (aPointPtr[2]/aPointPtr[3]); 
  568.            }
  569.            if ((aPointPtr[2]/aPointPtr[3]) > boundingBox[5])
  570.            { boundingBox[5] = (aPointPtr[2]/aPointPtr[3]); 
  571.            }
  572.            aPointPtr += 4;
  573.         }
  574.      }
  575.      i++;
  576.   }
  577.  
  578.   if (notFound)
  579.   {  NXLogError("unable to find any points token (RI_P, RI_Z, RI_PW) for %s - can't calculate bounding box...", [[self class] name]);
  580.      return nil;
  581.   }
  582.   dirtyBoundingBox = FALSE; 
  583.   return self;
  584. }
  585.  
  586.  
  587. - setBoundingBox:(RtBound *)newBoundingBox
  588. {
  589.   N3D_CopyBound(*newBoundingBox, boundingBox);
  590.  
  591.   return self;
  592. }
  593.  
  594. - getBoundingBox:(RtBound *)boundingBoxContainer
  595. {
  596.   N3D_CopyBound(boundingBox, *boundingBoxContainer);
  597.  
  598.   return self;
  599. }
  600.  
  601. - (RtBound *)boundingBoxStartingAt:(RtFloat)intervalStartTime endingAt:(RtFloat)intervalEndTime
  602. { 
  603.    if (dirtyBoundingBox) 
  604.    {  [self calculateBoundingBoxStartingAt:intervalStartTime endingAt:intervalEndTime];
  605.    }
  606.    return &boundingBox; 
  607. }
  608.  
  609. - setMyShape:shape { myShape = shape;  return self; }
  610.  
  611. - shape { return myShape; }
  612.  
  613. - (int)n { return n; }
  614. - (RtToken *)tokens { return tokens; }
  615. - (RtPointer *)parms { return parms; }
  616. - (char **)archiveVector { return archiveVector; }
  617. - (int *)printfNVector { return printfNVector; }
  618. - (int *)printfTypeVector { return printfTypeVector; }
  619.  
  620. - renderMaps:(WW3DCamera *)camera  startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime usingStream:(NXStream *)ns
  621. {
  622.   return self;
  623. }
  624.  
  625. - renderMaps:(WW3DCamera *)camera usingStream:(NXStream *)ns
  626. {
  627.   RtFloat  shutterOpenTime = [camera shutterOpenTime],
  628.            shutterCloseTime = [camera shutterCloseTime];
  629.  
  630.  
  631.   return [self renderMaps:camera startingAt:shutterOpenTime endingAt:shutterCloseTime usingStream:(NXStream *)ns];
  632. }
  633.  
  634. - renderMaps:(WW3DCamera *)camera  startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime
  635. {
  636.   return self;
  637. }
  638.  
  639. - renderMaps:(WW3DCamera *)camera
  640. {
  641.   RtFloat  shutterOpenTime = [camera shutterOpenTime],
  642.            shutterCloseTime = [camera shutterCloseTime];
  643.  
  644.  
  645.   return [self renderMaps:camera startingAt:shutterOpenTime endingAt:shutterCloseTime];
  646. }
  647.  
  648. - renderSelfAsBox:(WW3DCamera *)camera  startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime
  649. {
  650.   if ([self hasBoundingBox])
  651.   {  // if I have a bounding box, don't render myself
  652.   }
  653.   else
  654.   {  // otherwise, render myself like normal
  655.      [self renderSelf:camera  startingAt:shutterOpenTime endingAt:shutterCloseTime];
  656.   }
  657.  
  658.   // the idea here is that if it has a boundingBox, we don't want to
  659.   // render it (since it has some real geometry, and the whole point of
  660.   // this routine is to avoid drawing geometry).  If, on the other hand, it
  661.   // doesn't have a bounding box, it (at most) just transforms the current
  662.   // transformation matrix.
  663.  
  664.   return self;
  665. }
  666.  
  667.  
  668. - renderSelf:(WW3DCamera *)camera  startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime
  669. {
  670.   char comment[256];
  671.  
  672.   sprintf(comment, "RIBCommand subclass %s called", [self name]);
  673.   RiArchiveRecord("comment", comment);
  674.   return self;
  675. }
  676.  
  677. - renderSelf:(WW3DCamera *)camera
  678. {
  679.   RtFloat  shutterOpenTime = [camera shutterOpenTime],
  680.            shutterCloseTime = [camera shutterCloseTime];
  681.  
  682.  
  683.   return [self renderSelf:camera startingAt:shutterOpenTime endingAt:shutterCloseTime];
  684. }
  685.  
  686. - preRenderSelf:(WW3DCamera *)camera  startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime
  687. {
  688.   RiArchiveRecord("comment", "RIBCommand called"); 
  689.   return self;
  690. }
  691.  
  692. - preRenderSelf:(WW3DCamera *)camera
  693. {
  694.   RtFloat  shutterOpenTime = [camera shutterOpenTime],
  695.            shutterCloseTime = [camera shutterCloseTime];
  696.  
  697.  
  698.   return [self renderSelf:camera startingAt:shutterOpenTime endingAt:shutterCloseTime];
  699. }
  700.  
  701. - transformCTM:(WW3DAttributeState *)attributeState startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime { return self; }
  702.  
  703. - (BOOL)isMotionBlurrable { return NO; }
  704.  
  705. - (BOOL)isCompoundCommand { return NO; }
  706.  
  707. - (BOOL)isLerpable { return NO; }
  708.  
  709. - (const char *)getInspectorClassName { return "RIBCommandIBInspector"; }
  710.  
  711. // WavesWorld archiving:
  712. // writeEve:(NXStream *)stream
  713. // writeScene:(NXStream *)stream
  714.  
  715. - writeEve:(NXStream *)stream atTabLevel:(int)tab
  716. {
  717.    int  i;
  718.  
  719.  
  720.    for (i = 0; i < tab; i++)
  721.    {  NXPrintf(stream, "\t");
  722.    }
  723.    NXPrintf(stream, "#RIBCommand %s called;", [self name]); 
  724.    return self;
  725. }
  726.  
  727. - writeScene:(NXStream *)stream atTabLevel:(int)tab
  728. {
  729.    return [self writeEve:stream atTabLevel:tab];
  730. }
  731.  
  732.  
  733. - write3DTextScene:(NXStream *)stream atTabLevel:(int)tab index:(int)index time:(float)time until:(float)lastTime
  734. {
  735.    int  i;
  736.  
  737.  
  738.    for (i = 0; i < tab; i++)
  739.    {  NXPrintf(stream, "\t");
  740.    }
  741.  
  742.    NXPrintf(stream, "set __text__(color%s) {1 1 1}\n", [[self class] name]);
  743.    NXPrintf(stream, "startShape %s; EveCmd {Color $__text__(color%s)}; ", [[self class] name], [[self class] name]);
  744.    // need tab
  745.    // need index (position in current list)
  746.    NXPrintf(stream, 
  747.         "EveCmd {Translate [expr { %d * $__text__(tabLength)}] [expr {$__text__(spacingFactor) * %d * $__text__(spacing) * $__text__(fontSize)}] 0 };\n", 
  748.             tab, index); 
  749.    for (i = 0; i < tab; i++)
  750.    {  NXPrintf(stream, "\t");
  751.    }
  752.    NXPrintf(stream, "  EveCmd {WW3DText $__text__(fontName) $__text__(fontSize) {");
  753.    [self writeEve:stream atTabLevel:tab];
  754.    NXPrintf(stream, "} left;}\n");
  755.   NXPrintf(stream, "endShape;\n");
  756.  
  757.   return self;
  758. }
  759.  
  760.  
  761. // this is a routine for subclasses to call when archiving themselves to an Inventor file...
  762. - writeParameterListForInventor:(NXStream *)stream atTabLevel:(int)tab
  763. {
  764.   int  i, j, k;
  765.  
  766.   
  767.    if (!n)
  768.    {  return nil;
  769.    }
  770.  
  771.    // so what's the best way to do this?  basically, since Inventor is
  772.    // pretty restricted in what it can support, we need to examine each
  773.    // token, see if it's one that Inventor supports, and if so, spit it out.
  774.    
  775.    // so what does Inventor support?
  776.    // basically, we want to be able to map the following:
  777.    // "P" -> Coordinate3
  778.    // "Pw" -> Coordinate4
  779.    // "N" -> Normal
  780.    // "st" -> TextureCoordinate2
  781.    // "s" "t" -> need to scan for both and generate TextureCoordinate2
  782.  
  783.    for (i = 0; i < n; i++)
  784.    {  
  785.       if (!strcmp("P", tokens[i]))
  786.       {  
  787.          // I can't think of any reason that there wouldn't at least
  788.          // two points, which the following assumes, but if there's 
  789.          // not, I should catch it and do the right thing, sigh...
  790.          if (printfNVector[i] < 6)
  791.          {  for (k = 0; k < tab; k++) {  NXPrintf(stream, "\t"); }
  792.             NXPrintf(stream, "# less than 2 points - unable to convert RenderMan P token to Inventor Coordinate3 node!\n");
  793.             break;
  794.          }
  795.  
  796.          j = 0;
  797.  
  798.          // write node name and first point
  799.          for (k = 0; k < tab; k++) {  NXPrintf(stream, "\t"); }
  800.          NXPrintf(stream, "Coordinate3 {\n");
  801.      for (k = 0; k < (tab+1); k++) {  NXPrintf(stream, "\t"); }
  802.          NXPrintf(stream, "point [%f ", *((RtFloat *)(parms[i]) + j)); j++;
  803.          NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j)); j++;
  804.          NXPrintf(stream, "%f,\n", *((RtFloat *)(parms[i]) + j)); j++;
  805.  
  806.          // loop over the points, writing them out
  807.          while (j < (printfNVector[i] - 3))
  808.      {  for (k = 0; k < (tab+1); k++) {  NXPrintf(stream, "\t"); }
  809.         NXPrintf(stream, "       %f ", *((RtFloat *)(parms[i]) + j)); j++;
  810.         NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j)); j++;
  811.         NXPrintf(stream, "%f,\n", *((RtFloat *)(parms[i]) + j)); j++;
  812.       }
  813.  
  814.          // finish up with the last one
  815.      for (k = 0; k < (tab+1); k++) {  NXPrintf(stream, "\t"); }
  816.      NXPrintf(stream, "       %f ", *((RtFloat *)(parms[i]) + j)); j++;
  817.      NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j)); j++;
  818.      NXPrintf(stream, "%f]\n", *((RtFloat *)(parms[i]) + j)); j++;
  819.  
  820.          // okay, cap it off and move on
  821.          for (k = 0; k < tab; k++) {  NXPrintf(stream, "\t"); }
  822.      NXPrintf(stream, "}\n", *((RtFloat *)(parms[i]) + j)); j++;
  823.      break;
  824.       }
  825.  
  826.       if (!strcmp("Pw", tokens[i]))
  827.       {  
  828.          // I can't think of any reason that there wouldn't at least
  829.          // two points, which the following assumes, but if there's 
  830.          // not, I should catch it and do the right thing, sigh...
  831.          if (printfNVector[i] < 8)
  832.          {  for (k = 0; k < tab; k++) {  NXPrintf(stream, "\t"); }
  833.             NXPrintf(stream, "# less than 2 points - unable to convert RenderMan Pw token to Inventor Coordinate4 node!\n");
  834.             break;
  835.          }
  836.  
  837.          j = 0;
  838.  
  839.          // write node name and first point
  840.          for (k = 0; k < tab; k++) {  NXPrintf(stream, "\t"); }
  841.          NXPrintf(stream, "Coordinate4 {\n");
  842.      for (k = 0; k < (tab+1); k++) {  NXPrintf(stream, "\t"); }
  843.          NXPrintf(stream, "point [%f ", *((RtFloat *)(parms[i]) + j)); j++;
  844.          NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j)); j++;
  845.          NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j)); j++;
  846.          NXPrintf(stream, "%f,\n", *((RtFloat *)(parms[i]) + j)); j++;
  847.  
  848.          // loop over the points, writing them out
  849.          while (j < (printfNVector[i] - 4))
  850.      {  for (k = 0; k < (tab+1); k++) {  NXPrintf(stream, "\t"); }
  851.         NXPrintf(stream, "       %f ", *((RtFloat *)(parms[i]) + j)); j++;
  852.         NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j)); j++;
  853.         NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j)); j++;
  854.         NXPrintf(stream, "%f,\n", *((RtFloat *)(parms[i]) + j)); j++;
  855.       }
  856.  
  857.          // finish up with the last one
  858.      for (k = 0; k < (tab+1); k++) {  NXPrintf(stream, "\t"); }
  859.      NXPrintf(stream, "       %f ", *((RtFloat *)(parms[i]) + j)); j++;
  860.      NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j)); j++;
  861.      NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j)); j++;
  862.      NXPrintf(stream, "%f]\n", *((RtFloat *)(parms[i]) + j)); j++;
  863.  
  864.          // okay, cap it off and move on
  865.          for (k = 0; k < tab; k++) {  NXPrintf(stream, "\t"); }
  866.      NXPrintf(stream, "}\n", *((RtFloat *)(parms[i]) + j)); j++;
  867.      break;
  868.      }
  869.    }
  870.    return self;
  871. }
  872.  
  873. - writeInventorAtTime:(float)currentTime to:(NXStream *)stream atTabLevel:(int)tab
  874. {
  875.    int  i;
  876.  
  877.  
  878.    for (i = 0; i < tab; i++)
  879.    {  NXPrintf(stream, "\t");
  880.    }
  881.    NXPrintf(stream, "# RIBCommand %s called;", [[self class] name]); 
  882.    return self;
  883.  
  884. }
  885.  
  886.  
  887. // this is a routine for subclasses to call when archiving themselves to an eve file or a scene...
  888. - writeParameterList:(NXStream *)stream
  889. {
  890.   int  i, j;
  891.  
  892.   
  893.    if (!n)
  894.    {  NXPrintf(stream, ";");
  895.       return nil;
  896.    }
  897.    for (i = 0; i < n; i++)
  898.    {  NXPrintf(stream, "{%s} ", tokens[i]);
  899.       switch (printfTypeVector[i])
  900.       {  case WW_FLOAT:   NXPrintf(stream, "{ ");
  901.                           for (j = 0; j < printfNVector[i]; j++)
  902.                       {  NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j));
  903.               }
  904.                       NXPrintf(stream, "} ");  
  905.                           break;
  906.          case WW_COLOR:   NXPrintf(stream, "{ ");
  907.                           for (j = 0; j < printfNVector[i]; j++)
  908.                        {  NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j));
  909.               }
  910.                       NXPrintf(stream, "} ");  
  911.                           break;
  912.          case WW_POINT:   NXPrintf(stream, "{ ");
  913.                           for (j = 0; j < printfNVector[i]; j++)
  914.                        {  NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j));
  915.               }
  916.                       NXPrintf(stream, "} ");  
  917.                           break;
  918.          case WW_INT:     NXPrintf(stream, "{ ");
  919.                           for (j = 0; j < printfNVector[i]; j++)
  920.                        {  NXPrintf(stream, "%d ", *((int *)(parms[i]) + j));
  921.               }
  922.                       NXPrintf(stream, "} ");  
  923.                           break;
  924.          case WW_STRING:  for (j = 0; j < printfNVector[i]; j++)
  925.                        {  NXPrintf(stream, "{%s} ", *((char **)(parms[i]) + j));
  926.               }
  927.                           break;
  928.       }      
  929.    }
  930.    NXPrintf(stream, ";");
  931.    return self;
  932. }
  933.  
  934.  
  935.  
  936. // NeXTSTEP archiving:
  937.  
  938. #define typeVector "i"
  939. #define typeValues &n
  940.  
  941. - read:(NXTypedStream*)stream 
  942. {
  943.   int version, i, arrayLength;
  944.  
  945.  
  946.   [super read:stream];
  947.  
  948.   version = NXTypedStreamClassVersion(stream,"RIBCommand");
  949.   if (version == 0) NXReadTypes(stream,"i",&version), version=1;
  950.   if (version == 1)
  951.   {  NXReadArray(stream, "f", 6, boundingBox);
  952.      NXReadTypes(stream, typeVector, typeValues);
  953.      myShape = NXReadObject(stream);
  954. NX_DURING
  955.      if (n)
  956.      {  if ([self zone])
  957.         {  tokens = (char **)NXZoneMalloc([self zone], sizeof(char *) * n);
  958.            archiveVector = (char **)NXZoneMalloc([self zone], sizeof(char *) * n);
  959.            parms = (RtPointer *)NXZoneMalloc([self zone], sizeof(RtPointer) * n);
  960.         }
  961.         else
  962.         {  tokens = (char **)malloc(sizeof(char *) * n);
  963.            archiveVector = (char **)malloc(sizeof(char *) * n);
  964.            parms = (RtPointer *)malloc(sizeof(RtPointer) * n);
  965.         }
  966.         for (i = 0; i < n; i++)
  967.         {  //NXLogError("RIBCommand: attempting to read token[%d] and archiveVector[%d] of %d...\n", i, i, n);
  968.            NXReadTypes(stream, "**", &(tokens[i]), &(archiveVector[i]));
  969.            //NXLogError("RIBCommand: read: tokens[%d] == <%s> archiveVector[%d] == <%s>\n", 
  970.            //           i, tokens[i], i, archiveVector[i]);
  971.            //NXLogError("RIBCommand: got 'em!\n");
  972.            //NXLogError("RIBCommand: attempting to read parm[%d] using archiveVector <%s>...\n", i, archiveVector[i]);
  973.  
  974.            // archiveVector is of the form [%df] or [%di]
  975.            // therefore, we can check the second to last character, and key off that
  976.            if (*(archiveVector[i] + strlen(archiveVector[i]) - 2) == 'f')
  977.            {  //  it's a float
  978.               sscanf(archiveVector[i], "[%df]", &arrayLength);
  979.               if ([self zone])
  980.               {  parms[i] = (float *)NXZoneMalloc([self zone], sizeof(float) * arrayLength);
  981.               }
  982.               else
  983.               {  parms[i] = (float *)malloc(sizeof(float) * arrayLength);
  984.               }
  985.               if (!parms[i]) 
  986.               {  NXLogError("Yikes! Unable to allocate %d bytes in read: for %s\n", 
  987.                             (sizeof(float) * arrayLength), [[self class] name]);
  988.               }
  989.               else
  990.               {  NXReadArray(stream, "f", arrayLength, parms[i]);
  991.               }
  992.            }
  993.            else
  994.            {  if (*(archiveVector[i] + strlen(archiveVector[i]) - 2) == 'i')
  995.               {  //  it's an integer
  996.                  sscanf(archiveVector[i], "[%di]", &arrayLength);
  997.                  if ([self zone])
  998.                  {  parms[i] = (int *)NXZoneMalloc([self zone], sizeof(int) * arrayLength);
  999.           }
  1000.                  else
  1001.                  {  parms[i] = (int *)malloc(sizeof(int) * arrayLength);
  1002.           }
  1003.                  if (!parms[i]) 
  1004.                  {  NXLogError("Yikes! Unable to allocate %d bytes in read: for %s\n", 
  1005.                                (sizeof(int) * arrayLength), [[self class] name]);
  1006.                  }
  1007.                  else
  1008.                  {  NXReadArray(stream, "i", arrayLength, parms[i]);
  1009.                  }
  1010.            }
  1011.               else
  1012.               {  NXLogError("unable to decipher archiveVector[%d] == %s - didn't read the corresponding data\n", i, archiveVector[i]);
  1013.               }
  1014.            }
  1015.            //NXLogError("RIBCommand: got it!\n");
  1016.         }
  1017.      } 
  1018. NX_HANDLER
  1019.    NXLogError("in read:'ing the parameter list for RIBCommand, the subclass %s, exception [%d] raised where i == %d (n == %d).\n", 
  1020.                  [[self class] name], NXLocalHandler.code, i, n);
  1021.    return nil;
  1022. NX_ENDHANDLER
  1023.    }
  1024.  
  1025.   return self; 
  1026. }
  1027.  
  1028. - write:(NXTypedStream*)stream 
  1029. {
  1030.   int  i, arrayLength;
  1031.  
  1032.     
  1033.   [super write:stream];
  1034.  
  1035.   NXWriteArray(stream, "f", 6, boundingBox);
  1036.   NXWriteTypes(stream,typeVector, typeValues);
  1037.   NXWriteObjectReference(stream, myShape);
  1038. NX_DURING
  1039.   for (i = 0; i < n; i++)
  1040.   {  //NXLogError("RIBCommand: write: tokens[%d] == <%s> archiveVector[%d] == <%s>\n", 
  1041.      //           i, tokens[i], i, archiveVector[i]);
  1042.      NXWriteTypes(stream, "**", &(tokens[i]), &(archiveVector[i]));
  1043.  
  1044.      // archiveVector is of the form [%df] or [%di]
  1045.      // therefore, we can check the second to last character, and key off that
  1046.      if (*(archiveVector[i] + strlen(archiveVector[i]) - 2) == 'f')
  1047.      {  //  it's a float
  1048.         sscanf(archiveVector[i], "[%df]", &arrayLength);
  1049.         NXWriteArray(stream, "f", arrayLength, parms[i]);
  1050.      }
  1051.      else
  1052.      {  if (*(archiveVector[i] + strlen(archiveVector[i]) - 2) == 'i')
  1053.         {  //  it's an integer
  1054.            sscanf(archiveVector[i], "[%di]", &arrayLength);
  1055.            NXWriteArray(stream, "i", arrayLength, parms[i]);
  1056.         }
  1057.         else
  1058.         {  NXLogError("unable to decipher archiveVector[%d] == %s - didn't write the corresponding data\n", i, archiveVector[i]);
  1059.         }
  1060.      }
  1061.   }
  1062. NX_HANDLER
  1063.    NXLogError("in write:'ing the parameter list for RIBCommand, the subclass %s, exception [%d] raised where i == %d (n == %d).\n", 
  1064.                  [[self class] name], NXLocalHandler.code, i, n);
  1065.    return nil;
  1066. NX_ENDHANDLER
  1067.  
  1068.   return self;
  1069. }
  1070.  
  1071.  
  1072. // boy, this is dumb... This is to get around the stupid warnings from the compiler - ask wave for details
  1073. - class { return [super class]; }
  1074.  
  1075. @end
  1076.